package cn.tedu.csmall.product.service.impl;

import cn.tedu.csmall.product.ex.ServiceException;
import cn.tedu.csmall.product.mapper.*;
import cn.tedu.csmall.product.pojo.dto.BrandAddNewDTO;
import cn.tedu.csmall.product.pojo.dto.CategoryAddNewDTO;
import cn.tedu.csmall.product.pojo.dto.CategoryUpdateDTO;
import cn.tedu.csmall.product.pojo.entity.Brand;
import cn.tedu.csmall.product.pojo.entity.Category;
import cn.tedu.csmall.product.pojo.vo.AlbumStandardVO;
import cn.tedu.csmall.product.pojo.vo.CategoryListItemVO;
import cn.tedu.csmall.product.pojo.vo.CategoryStandardVO;
import cn.tedu.csmall.product.service.IBrandService;
import cn.tedu.csmall.product.service.ICategoryService;
import cn.tedu.csmall.product.web.ServiceCode;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Slf4j
@Service
public class CategoryServiceImpl implements ICategoryService {

    @Autowired
    private CategoryMapper categoryMapper;
    @Autowired
    private BrandCategoryMapper brandCategoryMapper;
    @Autowired
    private CategoryAttributeTemplateMapper categoryAttributeTemplateMapper;
    @Autowired
    private SpuMapper spuMapper;

    public CategoryServiceImpl() {
        log.debug("创建业务对象: CategoryServiceImpl");
    }



    @Transactional
    @Override
    public void addNew(CategoryAddNewDTO categoryAddNewDTO) {
        log.debug("开始处理添加类别业务,参数: {}", categoryAddNewDTO);

        //查询父级类别
        Integer depth = 1;
        Long parentId = categoryAddNewDTO.getParentId();
        CategoryStandardVO parentCategory = null;
        if(parentId != 0){
            //确定当前类别的depth值,为: 父级depth + 1
            parentCategory
                    = categoryMapper.getStandardById(parentId);
            log.debug("根据父级类别ID【{}】查询父级类别详情，结果：{}", parentId, parentCategory);
            if(parentCategory == null){
                String message = "添加类别失败,所选择的父级类别不存在! ";
                log.debug(message);
                throw new ServiceException(ServiceCode.ERR_NOT_FOUND,message);
            }
                depth = parentCategory.getDepth() + 1;

        }
        log.debug("当前尝试添加的类型的depth的值为 {}"+depth);

        //调用Mapper对象的【根据名称统计数量】方法进行统计
        String categoryName = categoryAddNewDTO.getName();
        //
        int count = categoryMapper.countByName(categoryName);
        log.debug("根据名称【{}】统计数量：{}", categoryName, count);
        if(count>0){
            //是: 类别名称已经被占用,添加类别失败,抛出异常
            String message = "添加类别失败，尝试添加的类别名称【" + categoryName + "】已经存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT,message);
        }

        //创建Category实体类的对象
        Category category = new Category();
        //将参数DTO的各属性值复制到Category实体类中
        BeanUtils.copyProperties(categoryAddNewDTO,category);
        // 补全Category对象的值：depth >>> 使用以上的depth变量
        category.setDepth(depth);
        // 补全Category对象的值：isParent >>> 0，新增的类别的isParent固定为0
        category.setIsParent(0);
        // 调用Mapper对象的方法，将数据插入到数据库，并获取返回值
        log.debug("准备向数据库中写入类别数据：{}", category);
        int rows = categoryMapper.insert(category);
        if (rows != 1) {
            String message = "添加类别失败，服务器忙，请稍后再尝试！";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERR_INSERT, message);
        }

        //category.getGmtCreate().toString();
        //  检查当前新增类型的父级类别，如果父类别的isParent为0，则将父级类别的isParent更新为1
            if(parentId !=0){
                if (parentCategory.getIsParent() == 0) {
                    Category updateParentCategory = new Category();
                    updateParentCategory.setId(parentId);
                    updateParentCategory.setIsParent(1);
                    log.debug("将父级类别的isParent更新为1,更新的参数对象:{}",updateParentCategory);
                    rows =categoryMapper.update(updateParentCategory);
                    if (rows != 1) {
                        String message = "添加类别失败，服务器忙，请稍后再尝试！";
                        log.debug(message);
                        throw new ServiceException(ServiceCode.ERR_UPDATE, message);
                    }
                }
            }
        }

    @Override
    public void setEnable(Long id) {
        updateEnableById(id, 1);
    }

    @Override
    public void setDisable(Long id) {
        updateEnableById(id, 0);
    }

    @Override
    public void setDisplay(Long id) {
        updateDisplayById(id, 1);
    }

    @Override
    public void setHidden(Long id) {
        updateDisplayById(id, 0);
    }

    @Override
    public CategoryStandardVO getStandardById(Long id) {
        log.debug("开始处理[根据id查询类别详情]的业务,参数: {}", id);
        // 调用Mapper对象的getStandardById()执行查询
        CategoryStandardVO queryResult = categoryMapper.getStandardById(id);
        if(queryResult == null){
            // 是：无此id对应的数据，将不允许执行查询操作，则抛出异常
            String message = "查询类别详情失败,尝试访问的数据不存在! ";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        // 调用Mapper对象的getStandardById()方法执行查询
        return queryResult;
    }

    @Override
    public List<CategoryListItemVO> list() {
        log.debug("开始处理【查询类别列表】的业务，无参数");
        return categoryMapper.list();
    }

    @Override
    public List<CategoryListItemVO> listByParentId(Long parentId) {
        log.debug("开始处理【根据父级类别查询其子集类别列表】的业务，无参数");
        return categoryMapper.listByParentId(parentId);
    }


    // 注意：删除时，如果删到某个类别没有子级了，需要将它的isParent更新为0
    @Override
    public void delete(Long id) {
        log.debug("开始处理[根据id删除类别]的业务,参数: {}", id);
        // 调用Mapper对象的getStandardById()执行查询
        CategoryStandardVO queryResult = categoryMapper.getStandardById(id);
        if(queryResult == null){
            // 是：无此id对应的数据，将不允许执行删除操作，则抛出异常
            String message = "删除类别失败,尝试访问的数据不存在! ";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        {
            int count = brandCategoryMapper.countByCategoryId(id);
            if (count > 0) {
                String message = "删除类别失败，此类别存在关联的品牌数据！";
                log.debug(message);
                throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
            }
        }
        {
            int count = categoryAttributeTemplateMapper.countByCategoryId(id);
            if (count > 0) {
                String message = "删除类别失败，此类别存在关联的属性模板数据！";
                log.debug(message);
                throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
            }
        }
        {
            int count = spuMapper.countByCategoryId(id);
            if (count > 0) {
                String message = "删除类别失败，此类别存在关联的SPU数据！";
                log.debug(message);
                throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
            }
        }

        // 调用Mapper对象的deleteById()方法执行删除
        log.debug("即将执行删除,参数:{}", id);
        categoryMapper.deleteById(id);

    }

    @Override
    public void updateById(CategoryUpdateDTO categoryUpdateDTO) {
        log.debug("开始处理[根据id修改类别详情]的业务,参数: {}", categoryUpdateDTO);
        // 调用Mapper对象的getStandardById()执行查询
        CategoryStandardVO queryResult = categoryMapper.getStandardById(categoryUpdateDTO.getId());
        if (queryResult == null) {
            // 是：无此id对应的数据，将不允许执行修改操作，则抛出异常
            String message = "修改类别详情失败,尝试访问的数据不存在! ";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        //从参数对象中获取类别名称
        String albumName = categoryUpdateDTO.getName();
        //检查类别名称是否已经被占用（类别表中是否已经存在此名称的数据）
        log.debug("检查类别名称是否已经被占用");
        int count = categoryMapper.countByName(albumName);
        if (count > 0) {
            //是: 类别名称已经被占用,修改类别详情失败,抛出异常
            String message = "修改类别详情失败，类别名称已经被占用！";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }
        {
            // 调用Mapper对象的updateById()方法执行修改
            log.debug("即将执行修改,参数:{}", categoryUpdateDTO);
            int rows = categoryMapper.updateById(categoryUpdateDTO);
            if (rows != 1) {
                String message = "修改类别详情失败，服务器忙，请稍后再尝试！";
                log.debug(message);
                throw new ServiceException(ServiceCode.ERR_DELETE, message);
            }
        }
    }

    private void updateEnableById(Long id, Integer enable) {
        String[] tips = {"禁用", "启用"};
        log.debug("开始处理【{}管理员】的业务，参数：{}", tips[enable], id);

        // 判断参数id是否为1
        if (id == 1) {
            String message = tips[enable] + "管理员失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        // 检查尝试访问的数据是否存在
        CategoryStandardVO queryResult = categoryMapper.getStandardById(id);
        if (queryResult == null) {
            String message = tips[enable] + "管理员失败，尝试访问的数据不存在！";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        // 判断状态是否冲突（当前已经是目标状态）
        if (queryResult.getEnable().equals(enable)) {
            String message = tips[enable] + "管理员失败，管理员账号已经处于" + tips[enable] + "状态！";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        // 准备执行更新
        Category category = new Category();
        category.setId(id);
        category.setEnable(enable);
        int rows = categoryMapper.update(category);
        if (rows != 1) {
            String message = tips[enable] + "管理员失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }

    private void updateDisplayById(Long id, Integer isDisplay) {
        String[] tips = {"隐藏", "显示"};
        log.debug("开始处理【{}类别】的业务，参数：{}", tips[isDisplay], id);
        // 调用Mapper对象的getDetailsById()方法执行查询
        CategoryStandardVO queryResult = categoryMapper.getStandardById(id);
        // 判断查询结果是否为null
        if (queryResult == null) {
            String message = tips[isDisplay] + "类别失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        // 判断查询结果中的enable是否为1
        if (queryResult.getIsDisplay().equals(isDisplay)) {
            String message = tips[isDisplay] + "类别失败，当前类别已经处于" + tips[isDisplay] + "状态！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        // 准备执行更新
        Category category = new Category();
        category.setId(id);
        category.setIsDisplay(isDisplay);
        int rows = categoryMapper.update(category);
        if (rows != 1) {
            String message = tips[isDisplay] + "类别失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }

    }

